home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 090 / tsort.cq / tsort.c
Text File  |  1985-08-02  |  9KB  |  218 lines
  1.   /* TSORT.C - A text file sort program */
  2.   /* Slightly rewritten to run under DRC and UNIX VER 7 C */
  3.   /* Usage:  TSORT <infile >outfile */
  4.  
  5. #include          <stdio.h>
  6. #include          <ctype.h>
  7.  
  8. #define  MAXWORD  80                           /* maximum word length */
  9. #define  NEWLINE  putc('\n',fp)     /* put carraige return in file fp */
  10.  
  11. struct text {               /* global declaration of tree node 'text' */
  12.              char word[MAXWORD];
  13.              struct text *lptr;
  14.              struct text *rptr;
  15. };
  16.  
  17. struct text *root;         /* global declaration of root of text tree */
  18.  
  19. main(argc, argv)
  20.   /*-----------------------------------------------------------------*/
  21.   /* driver for sort procedure.  Srt will sort lines of a specified  */
  22.   /* input file and place the result in either the stdout or a       */
  23.   /* specified output file.  Program is written for Lattice C but    */
  24.   /* functions provided in its library are documented so that srt    */
  25.   /* might be modified to suit your compiler.  If you have any       */
  26.   /* trouble or questions give me a call (if you can find me)        */
  27.   /*-----------------------------------------------------------------*/
  28.   /* Joe R Wyatt    2311 49th Lubbock, Tx 79412                      */
  29.   /* Home #: 806/793-5689    Office #: 806/763-8011 ext: 239         */
  30.   /*-----------------------------------------------------------------*/
  31.   /* Variables :        fp --     pointer to input file              */
  32.   /*                   fp2 --     ptr to output file                 */
  33.   /*                     c --     integer returned from getw.        */
  34.   /*                     i --     processed line count               */
  35.   /*                     j --     empty line count                   */
  36.   /*                  word --     temporary input line storage       */
  37.   /* Procedures:      getw --     included                           */
  38.   /*                 putwt --     included                           */
  39.   /*                 ptree --     included                           */
  40.   /* Functions :    printf --     string compare                     */
  41.   /*                 fopen --     open file and return file pointer  */
  42.   /*                  exit --     premature exit from program        */
  43.   /*                fclose --     close file                         */
  44.   /*-----------------------------------------------------------------*/
  45. int argc;
  46. char *argv[];
  47. {
  48.      FILE *fp, *fp2, *fopen();
  49.      int c, i, j;
  50.      char word[MAXWORD];
  51.  
  52.      root = NULL;                                /* root of text tree */
  53.      fp  = stdin;
  54.      fp2 = stdout;
  55.      i = 0;
  56.      j = 0;
  57.      while((c = getw(fp,word)) != EOF) {     /* get next line of file */
  58.           if (strlen(word) != 0) {
  59.                putwt(word);           /* if not null then put in tree */
  60.                i++;            /* increment number of lines processed */
  61.           }
  62.           else
  63.                j++;                 /* else inc number of empty lines */
  64.      }
  65.      fclose(fp);
  66.      ptree(fp2, root);                           /* print sorted tree */
  67.      printf("\nprocedure concluded.\n%d lines processed\n",i);
  68.      printf("%d empty lines ignored.\n",j);
  69.      fclose(fp2);
  70. }
  71.  
  72. putwt(w)
  73.   /*-----------------------------------------------------------------*/
  74.   /* procedure places 'w' in tree named 'text'.                      */
  75.   /* Parameters:         w --     null ended string                  */
  76.   /* Variables :      temp --     temporary pointer                  */
  77.   /*                   ptr --     ptr to node to place 'w' in.       */
  78.   /*                 value --     result of strcmp used for placement*/
  79.   /*                              in text tree.                      */
  80.   /* Procedures:    search --     included                           */
  81.   /* Functions :    strcmp --     string compare                     */
  82.   /*                getmem --     allocate memory for tree           */
  83.   /*                sizeof --     return size of structure           */
  84.   /*                printf --     print string to stdout             */
  85.   /*                strcpy --     string copy                        */
  86.   /*                  exit --     leave prgram prematurly            */
  87.   /*-----------------------------------------------------------------*/
  88. char *w;
  89. {
  90.      struct text *search(), *temp, *ptr;
  91.      int value = 1;
  92.  
  93.      temp = search(w);  /* locate position to place new node in tree */
  94.  
  95.      if (temp != NULL) /* if NULL then tree is empty. else compare keys */
  96.           value = strcmp(w, temp -> word);
  97.      if (value == 0)                    /* duplicate entry.  ignore. */
  98.           return;
  99.  
  100.      ptr = (struct text *)malloc(sizeof(struct text));
  101.      if (ptr == NULL) {                   /* memory allocation error */
  102.           printf("out of memory\n");
  103.           exit(1);
  104.      }
  105.        strcpy(ptr -> word, w);                     /* store new node */
  106.        ptr -> lptr = NULL;
  107.        ptr -> rptr = NULL;
  108.  
  109.      if (temp != NULL) {                   /* place new node in tree */
  110.           if (value > 0)
  111.                temp -> rptr = ptr;
  112.           else
  113.                temp -> lptr = ptr;
  114.           }
  115.      else
  116.           root = ptr;
  117.      return;
  118. }
  119.  
  120. struct text *search(w)
  121.   /*-----------------------------------------------------------------*/
  122.   /* procedure locates where 'w' is to be placed in text tree and    */
  123.   /* returns pointer to prior node.                                  */
  124.   /* procedure places 'w' in tree named 'text'.                      */
  125.   /* Parameters:         w --     null ended string                  */
  126.   /* Variables :      ptr1 --     temporary pointer                  */
  127.   /*                  ptr2 --     lags ptr1 by one node              */
  128.   /*                 value --     result of strcmp used for placement*/
  129.   /*                              in text tree.                      */
  130.   /* Functions :    strcmp --     string compare                     */
  131.   /*-----------------------------------------------------------------*/
  132. char *w;
  133. {
  134.      struct text *ptr1;
  135.      struct text *ptr2;
  136.      int value;
  137.  
  138.      ptr1 = root;                             /* initialize pointers */
  139.      ptr2 = root;
  140.      while(ptr1 != NULL) {
  141.           ptr2 = ptr1;
  142.           value = strcmp(w, ptr1 -> word);
  143.           if (value > 0)
  144.                ptr1 = ptr1 -> rptr;
  145.           else if (value < 0)
  146.                ptr1 = ptr1 -> lptr;
  147.           else
  148.                ptr1 = NULL;
  149.      }
  150.      return(ptr2);
  151. }
  152.  
  153. ptree(fp, ptr)
  154.   /*-----------------------------------------------------------------*/
  155.   /* recursive procedure to print contents of text tree.             */
  156.   /* Parameters:        fp --     pointer to output file.            */
  157.   /*                   ptr --     pointer to root of current subtree */
  158.   /* Procedures:      putw --     included                           */
  159.   /*-----------------------------------------------------------------*/
  160. FILE *fp;
  161. struct text *ptr;
  162. {
  163.      if (ptr != NULL) {
  164.           ptree(fp, ptr -> lptr);   /* find leftmost node of subtree */
  165.           putw(fp, ptr -> word);                       /* print data */
  166.           ptree(fp, ptr -> rptr);             /* print right subtree */
  167.      }
  168. }
  169.  
  170. #define EOW -2    /* end of word */
  171. getw(fp,w)
  172.   /*-----------------------------------------------------------------*/
  173.   /* gets next line in input file.                                   */
  174.   /* Parameters:        fp --     pointer to input file              */
  175.   /*                     w --     pointer to string for input        */
  176.   /* Variables :         c --     input character                    */
  177.   /*                     f --     end of word flag                   */
  178.   /*                 count --     number of characters               */
  179.   /* Functions :      getc --     get byte from input file           */
  180.   /*-----------------------------------------------------------------*/
  181. FILE *fp;
  182. char *w;
  183. {
  184.      int c,f,count;
  185.  
  186.      f = 0;                                 /* initialize local vars */
  187.      count = 0;
  188.      while (f != EOW && count < MAXWORD) {
  189.           c = getc(fp);
  190.           if (c != EOF && c != '\n') {       /* input to end of line */
  191.                count++;                    /* increment byte counter */
  192.                *w++ = c;
  193.           }
  194.           else
  195.                f = EOW; /* end of line reached or max chars exceded. */
  196.      }
  197.      *w = '\0';                  /* place null byte on end of string */
  198.      return(c);                         /* return last byte of input */
  199. }
  200.  
  201. putw(fp,w)
  202.   /*-----------------------------------------------------------------*/
  203.   /* prints string to output file.                                   */
  204.   /* Parameters:        fp --     pointer to input file              */
  205.   /*                     w --     pointer to string for input        */
  206.   /* Variables :         c --     output character                   */
  207.   /* Functions :      putc --     put byte to output file            */
  208.   /*-----------------------------------------------------------------*/
  209. FILE *fp;
  210. char *w;
  211. {
  212.      int c;
  213.  
  214.      while (*w != '\0')
  215.           putc(*w++, fp);
  216.      NEWLINE;
  217. }
  218.